using System;
using System.Collections.Generic;
using ns26;
using ns27;
using Triton.Game.Mono;

namespace Triton.Game.Mapping
{
	[Attribute38("Card")]
	public class Card : MonoBehaviour
	{
		[Attribute38("Card.SpellLoadRequest")]
		public class SpellLoadRequest : MonoClass
		{
			public string m_path => method_4("m_path");

			public SpellLoadRequest(IntPtr address, string className)
				: base(address, className)
			{
			}

			public SpellLoadRequest(IntPtr address)
				: this(address, "SpellLoadRequest")
			{
			}
		}

		public enum AnnouncerLineType
		{
			DEFAULT,
			BEFORE_VERSUS,
			AFTER_VERSUS,
			MAX
		}

		public static Vector3 ABOVE_DECK_OFFSET => MonoClass.smethod_6<Vector3>(TritonHs.MainAssemblyPath, "", "Card", "ABOVE_DECK_OFFSET");

		public static Vector3 IN_DECK_OFFSET => MonoClass.smethod_6<Vector3>(TritonHs.MainAssemblyPath, "", "Card", "IN_DECK_OFFSET");

		public static Vector3 IN_DECK_SCALE => MonoClass.smethod_6<Vector3>(TritonHs.MainAssemblyPath, "", "Card", "IN_DECK_SCALE");

		public static Vector3 IN_DECK_ANGLES => MonoClass.smethod_6<Vector3>(TritonHs.MainAssemblyPath, "", "Card", "IN_DECK_ANGLES");

		public static Quaternion IN_DECK_ROTATION => MonoClass.smethod_6<Quaternion>(TritonHs.MainAssemblyPath, "", "Card", "IN_DECK_ROTATION");

		public static Vector3 IN_DECK_HIDDEN_ANGLES => MonoClass.smethod_6<Vector3>(TritonHs.MainAssemblyPath, "", "Card", "IN_DECK_HIDDEN_ANGLES");

		public static Quaternion IN_DECK_HIDDEN_ROTATION => MonoClass.smethod_6<Quaternion>(TritonHs.MainAssemblyPath, "", "Card", "IN_DECK_HIDDEN_ROTATION");

		public static float DEFAULT_KEYWORD_DEATH_DELAY_SEC => MonoClass.smethod_6<float>(TritonHs.MainAssemblyPath, "", "Card", "DEFAULT_KEYWORD_DEATH_DELAY_SEC");

		public Entity m_entity => method_3<Entity>("m_entity");

		public CardDef m_cardDef => method_3<CardDef>("m_cardDef");

		public CardEffect m_playEffect => method_3<CardEffect>("m_playEffect");

		public List<CardEffect> m_additionalPlayEffects => method_3<Class271<CardEffect>>("m_additionalPlayEffects")?.method_25();

		public CardEffect m_attackEffect => method_3<CardEffect>("m_attackEffect");

		public CardEffect m_deathEffect => method_3<CardEffect>("m_deathEffect");

		public CardEffect m_lifetimeEffect => method_3<CardEffect>("m_lifetimeEffect");

		public List<CardEffect> m_subOptionEffects => method_3<Class271<CardEffect>>("m_subOptionEffects")?.method_25();

		public List<CardEffect> m_triggerEffects => method_3<Class271<CardEffect>>("m_triggerEffects")?.method_25();

		public List<CardEffect> m_allEffects => method_3<Class271<CardEffect>>("m_allEffects")?.method_25();

		public CardEffect m_customKeywordEffect => method_3<CardEffect>("m_customKeywordEffect");

		public CardEffect m_customChoiceRevealEffect => method_3<CardEffect>("m_customChoiceRevealEffect");

		public CardEffect m_customChoiceConcealEffect => method_3<CardEffect>("m_customChoiceConcealEffect");

		public List<CardSound> m_announcerLine => method_3<Class251<CardSound>>("m_announcerLine")?.method_25();

		public List<EmoteEntry> m_emotes => method_3<Class271<EmoteEntry>>("m_emotes")?.method_25();

		public Spell m_customSummonSpell => method_3<Spell>("m_customSummonSpell");

		public Spell m_customSpawnSpell => method_3<Spell>("m_customSpawnSpell");

		public Spell m_customSpawnSpellOverride => method_3<Spell>("m_customSpawnSpellOverride");

		public Spell m_customDeathSpell => method_3<Spell>("m_customDeathSpell");

		public Spell m_customDeathSpellOverride => method_3<Spell>("m_customDeathSpellOverride");

		public Spell m_customDiscardSpell => method_3<Spell>("m_customDiscardSpell");

		public Spell m_customDiscardSpellOverride => method_3<Spell>("m_customDiscardSpellOverride");

		public int m_spellLoadCount => method_2<int>("m_spellLoadCount");

		public string m_actorPath => method_4("m_actorPath");

		public Actor m_actor => method_3<Actor>("m_actor");

		public Actor m_actorWaitingToBeReplaced => method_3<Actor>("m_actorWaitingToBeReplaced");

		public bool m_actorReady => method_2<bool>("m_actorReady");

		public bool m_actorLoading => method_2<bool>("m_actorLoading");

		public bool m_transitioningZones => method_2<bool>("m_transitioningZones");

		public bool m_hasBeenGrabbedByEnemyActionHandler => method_2<bool>("m_hasBeenGrabbedByEnemyActionHandler");

		public Zone m_zone => method_3<Zone>("m_zone");

		public Zone m_prevZone => method_3<Zone>("m_prevZone");

		public int m_zonePosition => method_2<int>("m_zonePosition");

		public int m_predictedZonePosition => method_2<int>("m_predictedZonePosition");

		public bool m_doNotSort => method_2<bool>("m_doNotSort");

		public bool m_beingDrawnByOpponent => method_2<bool>("m_beingDrawnByOpponent");

		public bool m_cardStandInInteractive => method_2<bool>("m_cardStandInInteractive");

		public ZoneTransitionStyle m_transitionStyle => method_2<ZoneTransitionStyle>("m_transitionStyle");

		public bool m_doNotWarpToNewZone => method_2<bool>("m_doNotWarpToNewZone");

		public float m_transitionDelay => method_2<float>("m_transitionDelay");

		public bool m_holdingForLinkedCardSwitch => method_2<bool>("m_holdingForLinkedCardSwitch");

		public bool m_shouldShowTooltip => method_2<bool>("m_shouldShowTooltip");

		public bool m_showTooltip => method_2<bool>("m_showTooltip");

		public bool m_overPlayfield => method_2<bool>("m_overPlayfield");

		public bool m_mousedOver => method_2<bool>("m_mousedOver");

		public bool m_mousedOverByOpponent => method_2<bool>("m_mousedOverByOpponent");

		public bool m_shown => method_2<bool>("m_shown");

		public bool m_inputEnabled => method_2<bool>("m_inputEnabled");

		public bool m_attacking => method_2<bool>("m_attacking");

		public int m_activeDeathEffectCount => method_2<int>("m_activeDeathEffectCount");

		public bool m_ignoreDeath => method_2<bool>("m_ignoreDeath");

		public bool m_suppressDeathEffects => method_2<bool>("m_suppressDeathEffects");

		public bool m_suppressDeathSounds => method_2<bool>("m_suppressDeathSounds");

		public bool m_suppressKeywordDeaths => method_2<bool>("m_suppressKeywordDeaths");

		public float m_keywordDeathDelaySec => method_2<float>("m_keywordDeathDelaySec");

		public bool m_suppressActorTriggerSpell => method_2<bool>("m_suppressActorTriggerSpell");

		public bool m_suppressPlaySounds => method_2<bool>("m_suppressPlaySounds");

		public bool m_isBattleCrySource => method_2<bool>("m_isBattleCrySource");

		public bool m_secretTriggered => method_2<bool>("m_secretTriggered");

		public bool m_secretSheathed => method_2<bool>("m_secretSheathed");

		public bool m_isBaubleAnimating => method_2<bool>("m_isBaubleAnimating");

		public Spell m_activeSpawnSpell => method_3<Spell>("m_activeSpawnSpell");

		public float m_delayBeforeHideInNullZoneVisuals => method_2<float>("m_delayBeforeHideInNullZoneVisuals");

		public HeroPowerTooltip m_heroPowerTooltip => method_3<HeroPowerTooltip>("m_heroPowerTooltip");

		public Card(IntPtr address, string className)
			: base(address, className)
		{
		}

		public Card(IntPtr address)
			: this(address, "Card")
		{
		}

		public new string ToString()
		{
			return method_13("ToString");
		}

		public Entity GetEntity()
		{
			return method_14<Entity>("GetEntity", Array.Empty<object>());
		}

		public void SetEntity(Entity entity)
		{
			method_8("SetEntity", entity);
		}

		public void Destroy()
		{
			method_8("Destroy");
		}

		public Player GetController()
		{
			return method_14<Player>("GetController", Array.Empty<object>());
		}

		public Player.Side GetControllerSide()
		{
			return method_11<Player.Side>("GetControllerSide", Array.Empty<object>());
		}

		public Entity GetHero()
		{
			return method_14<Entity>("GetHero", Array.Empty<object>());
		}

		public Card GetHeroCard()
		{
			return method_14<Card>("GetHeroCard", Array.Empty<object>());
		}

		public Entity GetHeroPower()
		{
			return method_14<Entity>("GetHeroPower", Array.Empty<object>());
		}

		public Card GetHeroPowerCard()
		{
			return method_14<Card>("GetHeroPowerCard", Array.Empty<object>());
		}

		public TAG_PREMIUM GetPremium()
		{
			return method_11<TAG_PREMIUM>("GetPremium", Array.Empty<object>());
		}

		public bool IsOverPlayfield()
		{
			return method_11<bool>("IsOverPlayfield", Array.Empty<object>());
		}

		public void NotifyOverPlayfield()
		{
			method_8("NotifyOverPlayfield");
		}

		public void NotifyLeftPlayfield()
		{
			method_8("NotifyLeftPlayfield");
		}

		public void NotifyMousedOver()
		{
			method_8("NotifyMousedOver");
		}

		public void NotifyMousedOut()
		{
			method_8("NotifyMousedOut");
		}

		public bool IsMousedOver()
		{
			return method_11<bool>("IsMousedOver", Array.Empty<object>());
		}

		public void NotifyOpponentMousedOverThisCard()
		{
			method_8("NotifyOpponentMousedOverThisCard");
		}

		public void NotifyOpponentMousedOffThisCard()
		{
			method_8("NotifyOpponentMousedOffThisCard");
		}

		public void NotifyPickedUp()
		{
			method_8("NotifyPickedUp");
		}

		public void NotifyTargetingCanceled()
		{
			method_8("NotifyTargetingCanceled");
		}

		public bool IsInputEnabled()
		{
			return method_11<bool>("IsInputEnabled", Array.Empty<object>());
		}

		public void SetInputEnabled(bool enabled)
		{
			method_8("SetInputEnabled", enabled);
		}

		public bool IsAllowedToShowTooltip()
		{
			return method_11<bool>("IsAllowedToShowTooltip", Array.Empty<object>());
		}

		public bool IsAbleToShowTooltip()
		{
			return method_11<bool>("IsAbleToShowTooltip", Array.Empty<object>());
		}

		public bool GetShouldShowTooltip()
		{
			return method_11<bool>("GetShouldShowTooltip", Array.Empty<object>());
		}

		public void SetShouldShowTooltip()
		{
			method_8("SetShouldShowTooltip");
		}

		public void ShowTooltip()
		{
			method_8("ShowTooltip");
		}

		public void HideTooltip()
		{
			method_8("HideTooltip");
		}

		public bool IsShowingTooltip()
		{
			return method_11<bool>("IsShowingTooltip", Array.Empty<object>());
		}

		public void UpdateTooltip()
		{
			method_8("UpdateTooltip");
		}

		public bool IsAttacking()
		{
			return method_11<bool>("IsAttacking", Array.Empty<object>());
		}

		public void EnableAttacking(bool enable)
		{
			method_8("EnableAttacking", enable);
		}

		public bool WillIgnoreDeath()
		{
			return method_11<bool>("WillIgnoreDeath", Array.Empty<object>());
		}

		public void IgnoreDeath(bool ignore)
		{
			method_8("IgnoreDeath", ignore);
		}

		public bool WillSuppressDeathEffects()
		{
			return method_11<bool>("WillSuppressDeathEffects", Array.Empty<object>());
		}

		public void SuppressDeathEffects(bool suppress)
		{
			method_8("SuppressDeathEffects", suppress);
		}

		public bool WillSuppressDeathSounds()
		{
			return method_11<bool>("WillSuppressDeathSounds", Array.Empty<object>());
		}

		public void SuppressDeathSounds(bool suppress)
		{
			method_8("SuppressDeathSounds", suppress);
		}

		public bool WillSuppressKeywordDeaths()
		{
			return method_11<bool>("WillSuppressKeywordDeaths", Array.Empty<object>());
		}

		public void SuppressKeywordDeaths(bool suppress)
		{
			method_8("SuppressKeywordDeaths", suppress);
		}

		public float GetKeywordDeathDelaySec()
		{
			return method_11<float>("GetKeywordDeathDelaySec", Array.Empty<object>());
		}

		public void SetKeywordDeathDelaySec(float sec)
		{
			method_8("SetKeywordDeathDelaySec", sec);
		}

		public bool WillSuppressActorTriggerSpell()
		{
			return method_11<bool>("WillSuppressActorTriggerSpell", Array.Empty<object>());
		}

		public void SuppressActorTriggerSpell(bool suppress)
		{
			method_8("SuppressActorTriggerSpell", suppress);
		}

		public bool WillSuppressPlaySounds()
		{
			return method_11<bool>("WillSuppressPlaySounds", Array.Empty<object>());
		}

		public void SuppressPlaySounds(bool suppress)
		{
			method_8("SuppressPlaySounds", suppress);
		}

		public bool IsShown()
		{
			return method_11<bool>("IsShown", Array.Empty<object>());
		}

		public void ShowCard()
		{
			method_8("ShowCard");
		}

		public void ShowImpl()
		{
			method_8("ShowImpl");
		}

		public void HideCard()
		{
			method_8("HideCard");
		}

		public void HideImpl()
		{
			method_8("HideImpl");
		}

		public void SetBattleCrySource(bool source)
		{
			method_8("SetBattleCrySource", source);
		}

		public void DoTauntNotification()
		{
			method_8("DoTauntNotification");
		}

		public void UpdateProposedManaUsage()
		{
			method_8("UpdateProposedManaUsage");
		}

		public CardDef GetCardDef()
		{
			return method_14<CardDef>("GetCardDef", Array.Empty<object>());
		}

		public void LoadCardDef(CardDef cardDef, bool updateActor)
		{
			method_8("LoadCardDef", cardDef, updateActor);
		}

		public void PurgeSpells()
		{
			method_8("PurgeSpells");
		}

		public bool ShouldPreloadCardAssets()
		{
			return method_11<bool>("ShouldPreloadCardAssets", Array.Empty<object>());
		}

		public void OverrideCustomSpawnSpell(Spell spell)
		{
			method_8("OverrideCustomSpawnSpell", spell);
		}

		public void OverrideCustomDeathSpell(Spell spell)
		{
			method_8("OverrideCustomDeathSpell", spell);
		}

		public void OverrideCustomDiscardSpell(Spell spell)
		{
			method_8("OverrideCustomDiscardSpell", spell);
		}

		public Texture GetPortraitTexture()
		{
			return method_14<Texture>("GetPortraitTexture", Array.Empty<object>());
		}

		public Material GetGoldenMaterial()
		{
			return method_14<Material>("GetGoldenMaterial", Array.Empty<object>());
		}

		public CardEffect GetPlayEffect(int index)
		{
			return method_14<CardEffect>("GetPlayEffect", new object[1] { index });
		}

		public CardEffect GetOrCreateProxyEffect(Network.HistBlockStart blockStart, CardEffectDef proxyEffectDef)
		{
			return method_14<CardEffect>("GetOrCreateProxyEffect", new object[2] { blockStart, proxyEffectDef });
		}

		public void DeactivatePlaySpell()
		{
			method_8("DeactivatePlaySpell");
		}

		public Spell GetPlaySpell(int index, bool loadIfNeeded)
		{
			return method_14<Spell>("GetPlaySpell", new object[2] { index, loadIfNeeded });
		}

		public List<CardSoundSpell> GetPlaySoundSpells(int index, bool loadIfNeeded)
		{
			return method_14<Class271<CardSoundSpell>>("GetPlaySoundSpells", new object[2] { index, loadIfNeeded })?.method_25();
		}

		public Spell GetAttackSpell(bool loadIfNeeded)
		{
			return method_14<Spell>("GetAttackSpell", new object[1] { loadIfNeeded });
		}

		public List<CardSoundSpell> GetAttackSoundSpells(bool loadIfNeeded)
		{
			return method_14<Class271<CardSoundSpell>>("GetAttackSoundSpells", new object[1] { loadIfNeeded })?.method_25();
		}

		public List<CardSoundSpell> GetDeathSoundSpells(bool loadIfNeeded)
		{
			return method_14<Class271<CardSoundSpell>>("GetDeathSoundSpells", new object[1] { loadIfNeeded })?.method_25();
		}

		public Spell GetLifetimeSpell(bool loadIfNeeded)
		{
			return method_14<Spell>("GetLifetimeSpell", new object[1] { loadIfNeeded });
		}

		public List<CardSoundSpell> GetLifetimeSoundSpells(bool loadIfNeeded)
		{
			return method_14<Class271<CardSoundSpell>>("GetLifetimeSoundSpells", new object[1] { loadIfNeeded })?.method_25();
		}

		public CardEffect GetSubOptionEffect(int suboption, int index)
		{
			return method_14<CardEffect>("GetSubOptionEffect", new object[2] { suboption, index });
		}

		public Spell GetSubOptionSpell(int suboption, int index, bool loadIfNeeded)
		{
			return method_14<Spell>("GetSubOptionSpell", new object[3] { suboption, index, loadIfNeeded });
		}

		public List<CardSoundSpell> GetSubOptionSoundSpells(int suboption, int index, bool loadIfNeeded)
		{
			return method_14<Class271<CardSoundSpell>>("GetSubOptionSoundSpells", new object[3] { suboption, index, loadIfNeeded })?.method_25();
		}

		public CardEffect GetTriggerEffect(int index)
		{
			return method_14<CardEffect>("GetTriggerEffect", new object[1] { index });
		}

		public Spell GetTriggerSpell(int index, bool loadIfNeeded)
		{
			return method_14<Spell>("GetTriggerSpell", new object[2] { index, loadIfNeeded });
		}

		public List<CardSoundSpell> GetTriggerSoundSpells(int index, bool loadIfNeeded)
		{
			return method_14<Class271<CardSoundSpell>>("GetTriggerSoundSpells", new object[2] { index, loadIfNeeded })?.method_25();
		}

		public Spell GetCustomKeywordSpell()
		{
			return method_14<Spell>("GetCustomKeywordSpell", Array.Empty<object>());
		}

		public Spell GetCustomSummonSpell()
		{
			return method_14<Spell>("GetCustomSummonSpell", Array.Empty<object>());
		}

		public Spell GetCustomSpawnSpell()
		{
			return method_14<Spell>("GetCustomSpawnSpell", Array.Empty<object>());
		}

		public Spell GetCustomSpawnSpellOverride()
		{
			return method_14<Spell>("GetCustomSpawnSpellOverride", Array.Empty<object>());
		}

		public Spell GetCustomDeathSpell()
		{
			return method_14<Spell>("GetCustomDeathSpell", Array.Empty<object>());
		}

		public Spell GetCustomDeathSpellOverride()
		{
			return method_14<Spell>("GetCustomDeathSpellOverride", Array.Empty<object>());
		}

		public Spell GetCustomChoiceRevealSpell()
		{
			return method_14<Spell>("GetCustomChoiceRevealSpell", Array.Empty<object>());
		}

		public Spell GetCustomChoiceConcealSpell()
		{
			return method_14<Spell>("GetCustomChoiceConcealSpell", Array.Empty<object>());
		}

		public Spell GetSpellTableOverride(SpellType spellType)
		{
			return method_14<Spell>("GetSpellTableOverride", new object[1] { spellType });
		}

		public EmoteEntry GetEmoteEntry(EmoteType emoteType)
		{
			return method_14<EmoteEntry>("GetEmoteEntry", new object[1] { emoteType });
		}

		public Spell GetBestSummonSpell()
		{
			return method_15<Spell>("GetBestSummonSpell", new Class276.Enum20[0], Array.Empty<object>());
		}

		public Spell GetBestSpawnSpell()
		{
			return method_15<Spell>("GetBestSpawnSpell", new Class276.Enum20[0], Array.Empty<object>());
		}

		public Spell GetBestDeathSpell()
		{
			return method_15<Spell>("GetBestDeathSpell", new Class276.Enum20[0], Array.Empty<object>());
		}

		public Spell GetBestDeathSpell(Actor actor)
		{
			return method_15<Spell>("GetBestDeathSpell", new Class276.Enum20[1] { Class276.Enum20.Class }, new object[1] { actor });
		}

		public void ActivateCharacterPlayEffects()
		{
			method_8("ActivateCharacterPlayEffects");
		}

		public void ActivateCharacterAttackEffects()
		{
			method_8("ActivateCharacterAttackEffects");
		}

		public void ActivateCharacterDeathEffects()
		{
			method_8("ActivateCharacterDeathEffects");
		}

		public void ActivateLifetimeEffects()
		{
			method_8("ActivateLifetimeEffects");
		}

		public void DeactivateLifetimeEffects()
		{
			method_8("DeactivateLifetimeEffects");
		}

		public void ActivateCustomKeywordEffect()
		{
			method_8("ActivateCustomKeywordEffect");
		}

		public void DeactivateCustomKeywordEffect()
		{
			method_8("DeactivateCustomKeywordEffect");
		}

		public bool ActivateSoundSpell(CardSoundSpell soundSpell)
		{
			return method_11<bool>("ActivateSoundSpell", new object[1] { soundSpell });
		}

		public bool HasActiveEmoteSound()
		{
			return method_11<bool>("HasActiveEmoteSound", Array.Empty<object>());
		}

		public bool HasUnfinishedEmoteSpell()
		{
			return method_11<bool>("HasUnfinishedEmoteSpell", Array.Empty<object>());
		}

		public CardSoundSpell PlayEmote(EmoteType emoteType)
		{
			return method_15<CardSoundSpell>("PlayEmote", new Class276.Enum20[1] { Class276.Enum20.ValueType }, new object[1] { emoteType });
		}

		public CardSoundSpell PlayEmote(EmoteType emoteType, Notification.SpeechBubbleDirection overrideDirection)
		{
			return method_15<CardSoundSpell>("PlayEmote", new Class276.Enum20[2]
			{
				Class276.Enum20.ValueType,
				Class276.Enum20.ValueType
			}, new object[2] { emoteType, overrideDirection });
		}

		public void InitCardDefAssets()
		{
			method_8("InitCardDefAssets");
		}

		public void InitEmoteList()
		{
			method_8("InitEmoteList");
		}

		public Spell SetupOverrideSpell(Spell existingSpell, Spell spell)
		{
			return method_14<Spell>("SetupOverrideSpell", new object[2] { existingSpell, spell });
		}

		public void DestroyCardDefAssets()
		{
			method_8("DestroyCardDefAssets");
		}

		public void DestroyEmoteList()
		{
			method_8("DestroyEmoteList");
		}

		public void CancelActiveSpells()
		{
			method_8("CancelActiveSpells");
		}

		public void OnTagsChanged(TagDeltaList changeList)
		{
			method_8("OnTagsChanged", changeList);
		}

		public void OnMetaData(Network.HistMetaData metaData)
		{
			method_8("OnMetaData", metaData);
		}

		public void HandleCardExhaustedTagChanged(TagDelta change)
		{
			method_8("HandleCardExhaustedTagChanged", change);
		}

		public void OnTagChanged(TagDelta change)
		{
			method_8("OnTagChanged", change);
		}

		public void UpdateQuestUI()
		{
			method_8("UpdateQuestUI");
		}

		public void UpdateCardCostHealth(TagDelta change)
		{
			method_8("UpdateCardCostHealth", change);
		}

		public bool CanShowActorVisuals()
		{
			return method_11<bool>("CanShowActorVisuals", Array.Empty<object>());
		}

		public bool ShouldShowImmuneVisuals()
		{
			return method_11<bool>("ShouldShowImmuneVisuals", Array.Empty<object>());
		}

		public void ActivateStateSpells()
		{
			method_8("ActivateStateSpells");
		}

		public void ActivateHandStateSpells()
		{
			method_8("ActivateHandStateSpells");
		}

		public void DeactivateHandStateSpells(Actor actor)
		{
			method_8("DeactivateHandStateSpells", actor);
		}

		public void ToggleDeathrattle(bool on)
		{
			method_8("ToggleDeathrattle", on);
		}

		public void UpdateBauble()
		{
			method_8("UpdateBauble");
		}

		public void DeactivateBaubles()
		{
			method_8("DeactivateBaubles");
		}

		public bool IsBaubleAnimating()
		{
			return method_11<bool>("IsBaubleAnimating", Array.Empty<object>());
		}

		public void SetIsBaubleAnimating(bool isAnimating)
		{
			method_8("SetIsBaubleAnimating", isAnimating);
		}

		public void ShowExhaustedChange(int val)
		{
			method_9("ShowExhaustedChange", new Class276.Enum20[1] { Class276.Enum20.I4 }, val);
		}

		public void ShowExhaustedChange(bool exhausted)
		{
			method_9("ShowExhaustedChange", new Class276.Enum20[1] { Class276.Enum20.Boolean }, exhausted);
		}

		public void SheatheWeapon()
		{
			method_8("SheatheWeapon");
		}

		public void UnSheatheWeapon()
		{
			method_8("UnSheatheWeapon");
		}

		public void SheatheSecret(Spell spell)
		{
			method_8("SheatheSecret", spell);
		}

		public void UnSheatheSecret(Spell spell)
		{
			method_8("UnSheatheSecret", spell);
		}

		public void OnEnchantmentAdded(int oldEnchantmentCount, Entity enchantment)
		{
			method_8("OnEnchantmentAdded", oldEnchantmentCount, enchantment);
		}

		public void OnEnchantmentRemoved(int oldEnchantmentCount, Entity enchantment)
		{
			method_8("OnEnchantmentRemoved", oldEnchantmentCount, enchantment);
		}

		public void OnEnchantmentSpellStateFinished(Spell spell, SpellStateType prevStateType, object userData)
		{
			method_8("OnEnchantmentSpellStateFinished", spell, prevStateType, userData);
		}

		public void UpdateEnchantments()
		{
			method_8("UpdateEnchantments");
		}

		public Spell GetActorSpell(SpellType spellType, bool loadIfNeeded)
		{
			return method_14<Spell>("GetActorSpell", new object[2] { spellType, loadIfNeeded });
		}

		public Spell ActivateActorSpell(SpellType spellType)
		{
			return method_15<Spell>("ActivateActorSpell", new Class276.Enum20[1] { Class276.Enum20.ValueType }, new object[1] { spellType });
		}

		public Spell ActivateActorSpell(Actor actor, SpellType spellType)
		{
			return method_15<Spell>("ActivateActorSpell", new Class276.Enum20[2]
			{
				Class276.Enum20.Class,
				Class276.Enum20.ValueType
			}, new object[2] { actor, spellType });
		}

		public Spell GetActorAttackSpellForInput()
		{
			return method_14<Spell>("GetActorAttackSpellForInput", Array.Empty<object>());
		}

		public void FakeDeath()
		{
			method_8("FakeDeath");
		}

		public Spell ActivateDeathSpell(Actor actor)
		{
			return method_14<Spell>("ActivateDeathSpell", new object[1] { actor });
		}

		public Spell ActivateHandSpawnSpell()
		{
			return method_14<Spell>("ActivateHandSpawnSpell", Array.Empty<object>());
		}

		public Spell ActivatePlaySpawnEffects()
		{
			return method_14<Spell>("ActivatePlaySpawnEffects", Array.Empty<object>());
		}

		public void ActivateCustomSpawnSpell(Spell spell)
		{
			method_8("ActivateCustomSpawnSpell", spell);
		}

		public void ActivateCustomHandSpawnSpell(Spell spell, Card creatorCard)
		{
			method_8("ActivateCustomHandSpawnSpell", spell, creatorCard);
		}

		public void ActivateMinionSpawnEffects()
		{
			method_8("ActivateMinionSpawnEffects");
		}

		public Spell ActivateCreatorSpawnMinionSpell()
		{
			return method_15<Spell>("ActivateCreatorSpawnMinionSpell", new Class276.Enum20[0], Array.Empty<object>());
		}

		public void ActivateStandardSpawnMinionSpell()
		{
			method_8("ActivateStandardSpawnMinionSpell");
		}

		public void ActivateCustomSpawnMinionSpell(Spell spell, Card creatorCard)
		{
			method_8("ActivateCustomSpawnMinionSpell", spell, creatorCard);
		}

		public void OnSpellFinished_StandardSpawnMinion(Spell spell, object userData)
		{
			method_8("OnSpellFinished_StandardSpawnMinion", spell, userData);
		}

		public void OnSpellFinished_CustomSpawnMinion(Spell spell, object userData)
		{
			method_8("OnSpellFinished_CustomSpawnMinion", spell, userData);
		}

		public void OnSpellFinished_DefaultHandSpawn(Spell spell, object userData)
		{
			method_8("OnSpellFinished_DefaultHandSpawn", spell, userData);
		}

		public void OnSpellFinished_CustomHandSpawn(Spell spell, object userData)
		{
			method_8("OnSpellFinished_CustomHandSpawn", spell, userData);
		}

		public void OnSpellFinished_DefaultPlaySpawn(Spell spell, object userData)
		{
			method_8("OnSpellFinished_DefaultPlaySpawn", spell, userData);
		}

		public void OnSpellFinished_CustomPlaySpawn(Spell spell, object userData)
		{
			method_8("OnSpellFinished_CustomPlaySpawn", spell, userData);
		}

		public void OnSpellFinished_StandardCardSummon(Spell spell, object userData)
		{
			method_8("OnSpellFinished_StandardCardSummon", spell, userData);
		}

		public void OnSpellFinished_UpdateActorComponents(Spell spell, object userData)
		{
			method_8("OnSpellFinished_UpdateActorComponents", spell, userData);
		}

		public void OnSpellFinished_Death(Spell spell, object userData)
		{
			method_8("OnSpellFinished_Death", spell, userData);
		}

		public void OnSpellStateFinished_DestroyActor(Spell spell, SpellStateType prevStateType, object userData)
		{
			method_8("OnSpellStateFinished_DestroyActor", spell, prevStateType, userData);
		}

		public void OnSpellStateFinished_DestroySpell(Spell spell, SpellStateType prevStateType, object userData)
		{
			method_8("OnSpellStateFinished_DestroySpell", spell, prevStateType, userData);
		}

		public void OnSpellStateFinished_CustomDeath(Spell spell, SpellStateType prevStateType, object userData)
		{
			method_8("OnSpellStateFinished_CustomDeath", spell, prevStateType, userData);
		}

		public void UpdateActorState(bool forceHighlightRefresh)
		{
			method_8("UpdateActorState", forceHighlightRefresh);
		}

		public bool DoChoiceHighlight(GameState state)
		{
			return method_11<bool>("DoChoiceHighlight", new object[1] { state });
		}

		public bool DoOptionHighlight(GameState state)
		{
			return method_11<bool>("DoOptionHighlight", new object[1] { state });
		}

		public bool DoSubOptionHighlight(GameState state)
		{
			return method_11<bool>("DoSubOptionHighlight", new object[1] { state });
		}

		public bool DoOptionTargetHighlight(GameState state)
		{
			return method_11<bool>("DoOptionTargetHighlight", new object[1] { state });
		}

		public Actor GetActor()
		{
			return method_14<Actor>("GetActor", Array.Empty<object>());
		}

		public void SetActor(Actor actor)
		{
			method_8("SetActor", actor);
		}

		public string GetActorAssetPath()
		{
			return method_13("GetActorAssetPath");
		}

		public void SetActorAssetPath(string actorName)
		{
			method_8("SetActorAssetPath", actorName);
		}

		public bool IsActorReady()
		{
			return method_11<bool>("IsActorReady", Array.Empty<object>());
		}

		public bool IsActorLoading()
		{
			return method_11<bool>("IsActorLoading", Array.Empty<object>());
		}

		public void UpdateActorComponents()
		{
			method_8("UpdateActorComponents");
		}

		public void RefreshActor()
		{
			method_8("RefreshActor");
		}

		public Zone GetZone()
		{
			return method_14<Zone>("GetZone", Array.Empty<object>());
		}

		public Zone GetPrevZone()
		{
			return method_14<Zone>("GetPrevZone", Array.Empty<object>());
		}

		public void SetZone(Zone zone)
		{
			method_8("SetZone", zone);
		}

		public int GetZonePosition()
		{
			return method_11<int>("GetZonePosition", Array.Empty<object>());
		}

		public void SetZonePosition(int pos)
		{
			method_8("SetZonePosition", pos);
		}

		public int GetPredictedZonePosition()
		{
			return method_11<int>("GetPredictedZonePosition", Array.Empty<object>());
		}

		public void SetPredictedZonePosition(int pos)
		{
			method_8("SetPredictedZonePosition", pos);
		}

		public ZoneTransitionStyle GetTransitionStyle()
		{
			return method_11<ZoneTransitionStyle>("GetTransitionStyle", Array.Empty<object>());
		}

		public void SetTransitionStyle(ZoneTransitionStyle style)
		{
			method_8("SetTransitionStyle", style);
		}

		public bool IsTransitioningZones()
		{
			return method_11<bool>("IsTransitioningZones", Array.Empty<object>());
		}

		public void EnableTransitioningZones(bool enable)
		{
			method_8("EnableTransitioningZones", enable);
		}

		public bool HasBeenGrabbedByEnemyActionHandler()
		{
			return method_11<bool>("HasBeenGrabbedByEnemyActionHandler", Array.Empty<object>());
		}

		public void MarkAsGrabbedByEnemyActionHandler(bool enable)
		{
			method_8("MarkAsGrabbedByEnemyActionHandler", enable);
		}

		public bool IsDoNotSort()
		{
			return method_11<bool>("IsDoNotSort", Array.Empty<object>());
		}

		public void SetDoNotSort(bool on)
		{
			method_8("SetDoNotSort", on);
		}

		public bool IsDoNotWarpToNewZone()
		{
			return method_11<bool>("IsDoNotWarpToNewZone", Array.Empty<object>());
		}

		public void SetDoNotWarpToNewZone(bool on)
		{
			method_8("SetDoNotWarpToNewZone", on);
		}

		public float GetTransitionDelay()
		{
			return method_11<float>("GetTransitionDelay", Array.Empty<object>());
		}

		public void SetTransitionDelay(float delay)
		{
			method_8("SetTransitionDelay", delay);
		}

		public bool IsHoldingForLinkedCardSwitch()
		{
			return method_11<bool>("IsHoldingForLinkedCardSwitch", Array.Empty<object>());
		}

		public void SetHoldingForLinkedCardSwitch(bool hold)
		{
			method_8("SetHoldingForLinkedCardSwitch", hold);
		}

		public void UpdateZoneFromTags()
		{
			method_8("UpdateZoneFromTags");
		}

		public void TransitionToZone(Zone zone)
		{
			method_8("TransitionToZone", zone);
		}

		public void UpdateActor(bool forceIfNullZone)
		{
			method_8("UpdateActor", forceIfNullZone);
		}

		public void LoadActorAndSpells()
		{
			method_8("LoadActorAndSpells");
		}

		public void OnCustomSummonSpellLoaded(AssetReference assetRef, GameObject go, object callbackData)
		{
			method_8("OnCustomSummonSpellLoaded", assetRef, go, callbackData);
		}

		public void OnCustomDeathSpellLoaded(AssetReference assetRef, GameObject go, object callbackData)
		{
			method_8("OnCustomDeathSpellLoaded", assetRef, go, callbackData);
		}

		public void OnCustomDiscardSpellLoaded(AssetReference assetRef, GameObject go, object callbackData)
		{
			method_8("OnCustomDiscardSpellLoaded", assetRef, go, callbackData);
		}

		public void OnCustomSpawnSpellLoaded(AssetReference assetRef, GameObject go, object callbackData)
		{
			method_8("OnCustomSpawnSpellLoaded", assetRef, go, callbackData);
		}

		public void FinishSpellLoad()
		{
			method_8("FinishSpellLoad");
		}

		public void LoadActor()
		{
			method_8("LoadActor");
		}

		public bool ShouldShowHeroPowerTooltip()
		{
			return method_11<bool>("ShouldShowHeroPowerTooltip", Array.Empty<object>());
		}

		public void CreateHeroPowerTooltip()
		{
			method_8("CreateHeroPowerTooltip");
		}

		public void OnActorLoaded(AssetReference assetRef, GameObject go, object callbackData)
		{
			method_8("OnActorLoaded", assetRef, go, callbackData);
		}

		public void FinishActorLoad(Actor oldActor)
		{
			method_8("FinishActorLoad", oldActor);
		}

		public void ForceLoadHandActor()
		{
			method_8("ForceLoadHandActor");
		}

		public void HideHeroPowerTooltip()
		{
			method_8("HideHeroPowerTooltip");
		}

		public void OnZoneChanged()
		{
			method_8("OnZoneChanged");
		}

		public void OnActorChanged(Actor oldActor)
		{
			method_8("OnActorChanged", oldActor);
		}

		public bool HandleGraveyardToDeck(Actor oldActor)
		{
			return method_11<bool>("HandleGraveyardToDeck", new object[1] { oldActor });
		}

		public bool HandleGraveyardToHand(Actor oldActor)
		{
			return method_11<bool>("HandleGraveyardToHand", new object[1] { oldActor });
		}

		public bool CardStandInIsInteractive()
		{
			return method_11<bool>("CardStandInIsInteractive", Array.Empty<object>());
		}

		public void ReadyCardForDraw()
		{
			method_8("ReadyCardForDraw");
		}

		public void DrawFriendlyCard()
		{
			method_8("DrawFriendlyCard");
		}

		public bool IsBeingDrawnByOpponent()
		{
			return method_11<bool>("IsBeingDrawnByOpponent", Array.Empty<object>());
		}

		public void DrawOpponentCard()
		{
			method_8("DrawOpponentCard");
		}

		public void AnimateDeckToPlay()
		{
			method_9("AnimateDeckToPlay", new Class276.Enum20[0]);
		}

		public void SetupDeckToPlayActor(Actor actor, GameObject actorObject)
		{
			method_8("SetupDeckToPlayActor", actor, actorObject);
		}

		public void MillCard()
		{
			method_8("MillCard");
		}

		public void ActivateActorSpells_HandToPlay(Actor oldActor)
		{
			method_8("ActivateActorSpells_HandToPlay", oldActor);
		}

		public void OnSpellFinished_HandToPlay_SummonOut(Spell spell, object userData)
		{
			method_8("OnSpellFinished_HandToPlay_SummonOut", spell, userData);
		}

		public void OnSpellFinished_HandToPlay_SummonIn(Spell spell, object userData)
		{
			method_8("OnSpellFinished_HandToPlay_SummonIn", spell, userData);
		}

		public bool ActivateActorSpells_HandToWeapon(Actor oldActor)
		{
			return method_11<bool>("ActivateActorSpells_HandToWeapon", new object[1] { oldActor });
		}

		public void OnSpellFinished_HandToWeapon_SummonOut(Spell spell, object userData)
		{
			method_8("OnSpellFinished_HandToWeapon_SummonOut", spell, userData);
		}

		public void DiscardCardBeingDrawn()
		{
			method_8("DiscardCardBeingDrawn");
		}

		public void DoDiscardAnimation()
		{
			method_8("DoDiscardAnimation");
		}

		public bool SwitchOutLinkedDrawnCard()
		{
			return method_11<bool>("SwitchOutLinkedDrawnCard", Array.Empty<object>());
		}

		public bool DoPlayToHandTransition(Actor oldActor, bool wasInGraveyard)
		{
			return method_11<bool>("DoPlayToHandTransition", new object[2] { oldActor, wasInGraveyard });
		}

		public bool ActivateActorSpells_PlayToHand(Actor oldActor, bool wasInGraveyard)
		{
			return method_11<bool>("ActivateActorSpells_PlayToHand", new object[2] { oldActor, wasInGraveyard });
		}

		public void OnSpellFinished_PlayToHand_SummonOut(Spell spell, object userData)
		{
			method_8("OnSpellFinished_PlayToHand_SummonOut", spell, userData);
		}

		public void OnSpellFinished_PlayToHand_SummonOut_FromGraveyard(Spell spell, object userData)
		{
			method_8("OnSpellFinished_PlayToHand_SummonOut_FromGraveyard", spell, userData);
		}

		public void ResumeLayoutForPlayZone()
		{
			method_8("ResumeLayoutForPlayZone");
		}

		public void OnSpellStateFinished_PlayToHand_OldActor_SummonOut(Spell spell, SpellStateType prevStateType, object userData)
		{
			method_8("OnSpellStateFinished_PlayToHand_OldActor_SummonOut", spell, prevStateType, userData);
		}

		public void OnSpellFinished_PlayToHand_SummonIn(Spell spell, object userData)
		{
			method_8("OnSpellFinished_PlayToHand_SummonIn", spell, userData);
		}

		public void DoPlayToDeckTransition(Actor playActor)
		{
			method_8("DoPlayToDeckTransition", playActor);
		}

		public void SetSecretTriggered(bool set)
		{
			method_8("SetSecretTriggered", set);
		}

		public bool WasSecretTriggered()
		{
			return method_11<bool>("WasSecretTriggered", Array.Empty<object>());
		}

		public bool CanShowSecretTrigger()
		{
			return method_11<bool>("CanShowSecretTrigger", Array.Empty<object>());
		}

		public void ShowSecretTrigger()
		{
			method_8("ShowSecretTrigger");
		}

		public bool CanShowSecretZoneCard()
		{
			return method_11<bool>("CanShowSecretZoneCard", Array.Empty<object>());
		}

		public void ShowSecretQuestBirth()
		{
			method_8("ShowSecretQuestBirth");
		}

		public bool CanShowSecretDeath()
		{
			return method_11<bool>("CanShowSecretDeath", Array.Empty<object>());
		}

		public void ShowSecretDeath(Actor oldActor)
		{
			method_8("ShowSecretDeath", oldActor);
		}

		public bool ShouldCardDrawWaitForTurnStartSpells()
		{
			return method_11<bool>("ShouldCardDrawWaitForTurnStartSpells", Array.Empty<object>());
		}

		public bool ShouldCardDrawWaitForTaskLists()
		{
			return method_11<bool>("ShouldCardDrawWaitForTaskLists", Array.Empty<object>());
		}

		public bool DoesTaskListBlockCardDraw(PowerTaskList taskList)
		{
			return method_11<bool>("DoesTaskListBlockCardDraw", new object[1] { taskList });
		}

		public void CutoffFriendlyCardDraw()
		{
			method_8("CutoffFriendlyCardDraw");
		}

		public void PrepareForDeathAnimation(Actor dyingActor)
		{
			method_8("PrepareForDeathAnimation", dyingActor);
		}

		public bool HandlePlayActorDeath(Actor oldActor)
		{
			return method_11<bool>("HandlePlayActorDeath", new object[1] { oldActor });
		}

		public bool DoesCardReturnFromGraveyard()
		{
			return method_11<bool>("DoesCardReturnFromGraveyard", Array.Empty<object>());
		}

		public bool DoesTaskListReturnCardFromGraveyard(PowerTaskList taskList)
		{
			return method_11<bool>("DoesTaskListReturnCardFromGraveyard", new object[1] { taskList });
		}

		public void SetDelayBeforeHideInNullZoneVisuals(float delay)
		{
			method_8("SetDelayBeforeHideInNullZoneVisuals", delay);
		}

		public void DoNullZoneVisuals()
		{
			method_8("DoNullZoneVisuals");
		}
	}
}
